COMMENT ⊗   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002			DDT User's Information
C00022 ENDMK
C⊗;
		DDT User's Information

DDT is a program debugging aid that is loaded into the same core image as
the program being debugged.  DDT can be entered via the monitor DDT command
or by a program transfer to the external label DDT or by a program transfer
to the address contained in the right half of JOBDDT.

DDT can also be entered as a result of executing an instruction on which
a breakpoint has been set.

Once DDT has been entered the user may examine and modify the contents of
his accumulators and other memory locations.  To return to the execution
of the program an $P command (proceed from a breakpoint) or adr$G (start
execution at adr) may be used.  When DDT is entered via the DDT command,
the PC of the interrupted program is stored in JOBOPC.

If DDT is entered directly (e.g., JRST @JOBDDT or by DDT monitor cmd),
then $P will attempt to continue from the PC stored in JOBOPC if and
only if the user-mode bit (10000,,0) is on in the left half of JOBOPC.
Thus if a user program stores a user-mode PC in JOBOPC and then jumps
to DDT, the $P command will continue at the PC the program set up in JOBOPC.

In Exec DDT (EDDT), upon direct entry to DDT, $P will attempt to continue
at the PC stored in PROCPC (the PC from PROCPC is stored away upon entry
to DDT and PROCPC is zeroed so that DDT won't accidentally proceed from
the same PC twice without PROCPC having been set up again).

User DDT and UEDDT now use special activation mode in order to let the
user edit his command before he is finished with it.  This means that the
only characters that activate (and therefore cannot be edited) are those
characters that act as commands without the use of altmode.  (Also, some
illegal command characters activate immediately, and the DDT command
characters that activate will do so even when appearing inside a string
where they are not taken as commands.)  DDT also activates the first
character after an altmode (since that character is almost always a
command character), and if that character is a digit, every subsequent
character up through the first non-digit.  Finally, a backspace typed in
an empty line will activate.  If there is some situation in which DDT
fails to activate the end of a command, you can force DDT to activate by
typing any activator, such as altmode (and then you can abort the extra
character with backspace); if you find you have to do this a lot, you can
disable DDT's use of special activation mode by setting the cell $M-5
non-zero, in which case DDT will activate on every character.  Please
report to ME any situations in which DDT fails to activate upon a complete
command.


The following is a quick summary of DDT for people who already know how
to work DDT in general.  For further information, consult DEC documentation

General -
	$ = Altmode
	n = a number
	$n = a decimal number always!


Input modes

$n%	Input a list of n-bit octal bytes, separated by commas, terminated by $.
	If n=0 use the byte mask ($M+2) to define arbitrary byte boundaries

"<delimiter>text<delimiter>
	Left justified ascii text (up to five characters)  Note: to get CRLF
	entered you must type both CR and LF.  If more than five characters
	are typed, only the last five are used.

"<character>$
	Right justified ascii character.

$"<delimiter>text<delimiter>
	Left justified sixbit text (lower case typin converted to upper case).
	The last six (or fewer) characters are used.

$"<character>$
	right justified ascii character

$$7"<delimiter>text<delimiter>
	Left adjuseted ASCIZ string, five characters per word.

$$"<delimiter>text<delimiter> or $$n"<delimiter>text<delimiter>  (n not 7)
	Left adjuseted sixbit string, six characters per word.  Ends with
	a zero byte or zero word.


Output modes
$A	Absolute

$C	Full word constant in current radix

$F	Floating point

$H	Halfword format

$nJ	Output in flag mode using the n-th flag table.
	Each flag table contains =36 radix50 flag names (flag name for
	bit 0 is first).  The first word in the list of flag tables is
	found by looking in $M+3 (FLGPTR).  Each word in the list of flag
	tables is a right-half pointer to a flag table and a left-half
	pointer to the next word in the list (a zero left half terminates).

$nL	Output right half of cell as left half flags using n-th flag table.
	This is suitable for looking at MOVSI or TLxx instructions.

$nO	Output cell in n-bit bytes
	If n=0 use the byte mask ($M+2) to define arbitrary byte boundaries

$R	Relocatable

$nR	Set typeout radix to n.

$S	Symbolic

$nT	n-bit text bytes.  If n is omitted output 7-bit ascii, left adjusted,
	except if the first byte is null, output one right adjusted character.
	If n is present it should be one of 5, 6, or 9: 6=sixbit, 5=radix50,
	9=Stanford ascii with bucky bits.  Other values of n presently print
	in 7-bit ascii.

$U	each halfword as numeric in the current radix, unless $10R in which
	case output full word in radix 10

$nV	Output right half of cell as right half flags using n-th flag table.
	This is suitable for looking at MOVEI or TRxx instructions.



Special Characters
addr/	open cell in current mode
addr[	open cell as a number in the current radix
addr]	open cell as symbolic
addr!	open cell and suppress typeout
addr\	open cell in current mode and don't change "."
CR	Closes and changes (if user typed a new value) the current cell.
LF	Like CR and opens .+1.
↑	Like CR and opens .-1.
TAB	Like CR then opens the cell pointed to by right side of current cell.
≥ (control ] on ttys)
	Closes and does NOT change the current cell then opens the cell
	pointed to by left side of current cell.
;	retype in current mode (usually following a temporary mode change)
=	retype like $U format (half word numeric in current radix)
$=	retype like $C format (full word numeric in current radix)
←	retype in symbolic mode.
?	typeout all undefined symbols


Searches

$M	Contains the search mask.  Put 1 bits in it where you want to look.

first<last>arg$E
	Effective address search for intructions pointing to arg in the 
	range first to last

first<last>arg$N
	Search for words NOT containing arg in the range first to last.

first<last>arg$W
	Search for words containing arg in the range first to last.

first<last>arg$$Z
	Write the value arg into all words in the range first to last.



Special values

.	(period) has the value of the current address

$I	(exec ddt) has the state of the PI system (CONI PI,)

$Q	Has the last value typed by ddt.

$nB	Address of the four words associated with breakpoint n.

	The first word contains the address of the breakpoint in the
	right half, and the address of the cell to open in the left
	half.

	The second word is the conditional instruction.  If this is zero, or
	if when exected it causes one skip, then the procede counter
	is decremented and if it becomes non-positive, the breakpoint occurs.
	If the conditional instruction does not skip, no break is taken.
	If the conditional instructions skips twice, the break is taken
	regardless of the procede counter.

	The third word is the procede counter.

	If the fourth word is non-zero it is assumed to be the address of
	an ASCIZ string which will be used to set $M-1 (see below) to
	cause this string to be used for input instead of TTY input.

$M-5	(User DDT) If non-zero, DDT does terminal input by character instead
	of by using special activation mode and line input.  This shouldn't
	be necessary, but is available in case there is some instance in which
	DDT fails to make a command character activate.
$M-4	(EXEC DDT) If non-zero, DDT output goes to the LPT
$M-3	(EXEC DDT) Stores APR CONI bits here when DDT is entered
$M-2	If non zero, this points to a routine to be called to output
	each character.  The character to be output is in T (ac 5) and
	the routine should return via POPJ 3, without having clobbered
	any acs.
$M-1	If non zero is taken as a byte pointer to an ASCIZ string which
	is used instead of the TTY for input.
$M	Search mask
$M+1	Parameter for symbolic disassembly. If the value disassembed
	minus the best symbol is less than this number (MXINC) then
	the dissambler will print the symbol name plus the difference,
	if the difference is larger than this value, then the value
	being disassembled will be printed as a number.
$M+2	Byte input/output mask for $0% and $0O commands.
$M+3	First word in the list of flag tables. (See $F.)

Symbol manipulations

$D	Suppress the last symbol typed.  Retype the same value.

sym$K	Suppress output of the named symbol

sym$$K	Suppress input and output of this symbol

sym$:	Open the symbol table of the program named sym.

$:	Type a list of all program names.

sym:	Define sym to be the currently open location.

val<sym:
	Define sym to have value val.

sym$&	Open the symbol table of the block named sym in the currently
	open program.  Also accessible will be all symbols in blocks
	that contain the opened block.

$&	Type a list of all block names in the currently open program.

Program control

adr1(adr2)$nB
	Set breakpoint n at adr1.  When breakpoint is hit it will type the
	contents of adr2.  The n and (adr2) are optional.

adr1(adr2)$$nB
	Same as above except DDT will procede from the breakpoint automatically.
	Auto procede continues until typin is present when the breakpoint is
	hit (see $$P).

$B	remove all breakpoints

0$nB	remove breakpoint n.

adr$G	Start execution at adr.  If adr is omitted, execution starts at
	the location pointed to by the right half of JOBSA (in exec DDT
	the right half of STARTA is used instead of JOBSA).   If  JOBSA
	(STARTA) contains a zero starting address, $G with no  argument
	is illegal.  Incidently STARTA is located at DDTBEG+0.

adr$$G	Same as adr$G except  the argument is stored in the right  half
	of JOBSA (or STARTA) for subsequent $G commands.

$P	Procede from breakpoint (or from PC that was in JOBOPC or PROCPC
	upon entry to DDT).

n$P	Procede n times from this breakpoint

$$P	Procede automatically until the typein is present at the breakpoint.

instr$X	Executes the instruction that was typed.  If no argument is given
	then the one instruction at the current breakpoint location is
	single-stepped.  Repetitions of $X cause subsequent instructions to
	be single stepped.  After single stepping, a $P command will return
	to the normal execution of the program.

Assembly operations

+-*'	are arithmetic operators

,	is a separator denoting ac or device field

,,	separates half-words

	numeric typin is octal except digits followed by a decimal point
	are radix 10, except if further digits following the point are
	typed, input is floating point.  Floating point number may be
	followed by E, an optional plus or minus, and an exponent.

()	swap the argument and add it into the assembled word.

@	Set bit 13 in the word being assembled.

blank	is a separator and adding operator in the word assembler.

sym&	sets block name to sym for the next symbol that's input.


Special commands only for UEDDT and/or EDDT:

↓	Like CR (except it used to deposit changes on the Librascope)

$n¬	(UEDDT only) Examine core image of Timesharing job n.
$$n¬	(UEDDT only) Examine core image of Timesharing job n using its symbols.
	[With the above two cmds, you cannot examine the job's upper segment.]

$¬ or $0¬	(UEDDT only) Examine the timesharing system, using the
	EXPGT to accomplish mapping.  Upon attempt to examine or deposit
	where there is no EXPGT entry, an error message is given, and only
	if you are just examining, physical memory will be examined instead.

$$¬ or $$0¬ 	(EDDT only) Send P2 into EDDT and connect to it until ¬ is typed.

$$¬ or $$0¬	(UEDDT only) Examine P2 memory using P2's symbols.

n$¬	(UEDDT only) Examine physical core, with page n being page 0 in
	the space being examined.  If n is negative, examination will be
	via the EXPGT.

Paper tape control (Special EXEC DDT version only)

$↑Q	(That's control-Q) Punch loader.
first<last$↑R
	Punch data from core range to tape.
addr$↑S	Punch addr as the starting address.
↑T	Punch currently open location as one tape data block
first<last$Y
	Read tape into core
first<last↑V
	Read tape and verify by comparing it with core.